NetNews Offline 2/NetNews Offline Volume 2.iso/news/comp/lang/c++-part2/10691

Text File | 1996-08-05 | 6.2 KB | 316 lines

Path: news.tu-harburg.de!usenet
From: Juri Jurkewitsch <[e-mail]>
Newsgroups: comp.lang.c++,comp.cad.autocad
Subject: A small program to test MSVC++4.0 compiler
Date: 9 Mar 1996 14:05:45 GMT
Organization: TU Hamburg-Harburg
Message-ID: <4hs37p$[e-mail]>
NNTP-Posting-Host: os2.ft2.tu-harburg.de
Mime-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
X-Mailer: Mozilla 1.1N (Windows; I; 16bit)

/*
   Hello to all who would help me or just will read it!

   I need to buy now MSVC++ to create application for AutoCAD R13.
   I would know which version of it can understand my program.

   There is a small sample that was correct compiled
   and executed under BC++4.5. It contains nested class
   definitions, both templates of class and function,
   class definitions inside the function, some MACROS.

   I tryed MSVC++1.5 for this example and got a lot of error messages.

   If you have MSVC++ later as 2.0, could you compile it and
   report results to me via e-mail?

   Thanks in advice.

   Yuri Yurkewitsch
*/

typedef int Boolean;

template <class T> class Value
{
    T * Data;
    int Size;
    public:

     Value(int size) { Size = size; Data = new T[size]; }
    ~Value() {delete[] Data;}

      T& operator = ( const T& n ) { Data[0] = n; return (T&)n; }
          operator T&() const {return Data[0];}
      T& operator[](int i) const {return Data[i];}
};

class BasePredicate
{
      const char *  Name;
      int           Offset;
      int           Size;

  protected:
                 BasePredicate( const char * name,
                 unsigned int offset, unsigned int size)
                 {
                    Name   = name;
                    Offset = offset;
                    Size = size;
                 }
};

template <class T> class Predicate : public BasePredicate
{
        protected:
        Value <T> TheValue;

        public:
              Predicate (const char * name, T & value,
                unsigned int offset, unsigned int size)
              : BasePredicate( name, offset, size ),
                 TheValue( value )
              {
              }

            operator Value <T> () const { return TheValue; }
            Value <T> operator = ( T value ) { return
TheValue = value; }
};

#define AP_PHANTOM( class, member )((class*)0L)->member
#define AP_SIZEOF( class, member )sizeof( AP_PHANTOM( class, member))
#define AP_OFFSET( class, member )(unsigned int)(char
*)&AP_PHANTOM(class,member)


#define AP_PREDICATE( type, member ) \
    static class P##member : public Predicate<##type##> \
    {        \
      public:\
          P##member( const char * commentar) \
          : Predicate<##type##> ( \
                (const char*) #member, \
                AP_PHANTOM( Object, member), \
                AP_OFFSET( Object, member), \
                AP_SIZEOF( Object, member)) \
            { \
            } \
        type& operator = ( const type & n ) { return
TheValue.operator = ( n); } \
        operator type&() const { return TheValue.operator type&
() ;} \
                \
              \
            \
    } member


class BaseRule
{
  protected:

          BaseRule ( const char * name)
          {
          }

  public:

          virtual Boolean _fire () = 0;
};

template <class A>  class Rule1 : public BaseRule
{
            A & TheA;

            public:

         Rule1<A>( const char * name, A & arg)
         : BaseRule( name ), TheA( arg)
         {
     }

         Boolean  fire( A & arg );
         virtual Boolean  _fire () { return fire( TheA ); }
};

template <class A>  static Rule1<A>*
        DeclareRule ( const char * name, A & arg1)
{
      return new Rule1<A>( name, arg1);
}
/***************************************************************/
template <class A, class B>  class Rule2 : public BaseRule
{
         A & TheA;
    const B & TheB;

         public:

            Rule2<A,B>(const char * name, A & arg1, const B &
arg2)
            : BaseRule( name ), TheA( arg1), TheB( arg2)
                        {
            }

            Boolean  fire( A & arg1, const B & arg2 );
            virtual Boolean  _fire ()
{ return fire( TheA, TheB ); }
};


template <class A, class B>  Rule2<A,B>*
        DeclareRule ( const char * name, A & arg1, B & arg2)
{
      return new Rule2<A,B>( name, arg1, arg2);
}
/***************************************************************/
template <class A, class B, class C>  class Rule3 : public BaseRule
{
            A & TheA;
  const  B & TheB;
  const  C & TheC;

            public:

            Rule3<A,B,C>(const char * name,
                                 A & arg1,
                                 const B & arg2, const C & arg3)
            : BaseRule( name ),
                        TheA( arg1), TheB( arg2), TheC( arg3)
                        {
                        }

            Boolean  fire( A & arg1, const B & arg2,
                                 const C & arg3 );
            virtual Boolean  _fire ()
                          { return fire( TheA, TheB, TheC ); }
};


template <class A, class B, class C>  Rule3<A,B,C>*
        DeclareRule ( const char * name,
            A & arg1, const B & arg2, const C & arg3 )
{
      return new Rule3<A,B,C>( name, arg1, arg2, arg3);
}
/***************************************************************/


class Test
{
    class Class;

    public:

    class Object
    {
        friend class Class;
     public:
        int N;
        int M;
    };

    class Predicate1
    {
    };

    class Predicate2
    {
    };

    static class Class
    {
        public:

        AP_PREDICATE( int , N );
        AP_PREDICATE( int , M );

        BaseRule * r;

        Class()
        {
          r = DeclareRule( "a Rule", N, M);
        }
    } TheClass;

};


Test::Class::PN Test::Class::N("Name");
Test::Class::PM Test::Class::M("Mass");

Boolean Rule2<Test::Class::PN,Test::Class::PM>::fire(
            Test::Class::PN & N,
        const Test::Class::PM & M)
{
    int X = M;
    N = M;

    return 0;
}

Boolean Rule1<int>::fire( int & arg1 )
{
    return (arg1 > 3);
}

Boolean Rule2<Test::Predicate1,Test::Predicate2>::fire(
                  Test::Predicate1 & p1,
                  const Test::Predicate2 & p2)
{
    return 0;
}

Boolean Rule2<int,float>::fire( int & arg1, const float & arg2)
{
    arg1 = 3 * (int) arg2;
    return 1;
}

Boolean Rule3<int,Test::Predicate1,Test::Predicate2>::fire(
     int & arg1,
     const Test::Predicate1 & arg2,
     const Test::Predicate2 & arg3)
{
    return 0;
}



void rules()
{
  int X;
  float Y;
  Test::Predicate1 P1;
  Test::Predicate2 P2;

  BaseRule * r0 = DeclareRule( "R0", P1 , P2 );
  BaseRule * r1 = DeclareRule( "R1", X );
  BaseRule * r2 = DeclareRule( "R2", X , Y );
  BaseRule * r3 = DeclareRule( "R3", X , P1, P2 );

  r0->_fire();
  r1->_fire();
  r2->_fire();
  r3->_fire();
}

Test::Class Test::TheClass;

int main ()
{
  rules();

  Test::TheClass.r->_fire();

  return 0;
}